home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / nt / gr564s.zip / SRC / CONF.SH < prev    next >
Linux/UNIX/POSIX Shell Script  |  1993-09-07  |  46KB  |  1,929 lines
  1. #!/bin/sh
  2. # Output RCS compile-time configuration.
  3. Id='$Id: conf.sh,v 5.18 1992/07/28 16:12:44 eggert Exp $'
  4. #    Copyright 1990, 1991, 1992 by Paul Eggert
  5. #    Distributed under license by the Free Software Foundation, Inc.
  6.  
  7. # This file is part of RCS.
  8. #
  9. # RCS is free software; you can redistribute it and/or modify
  10. # it under the terms of the GNU General Public License as published by
  11. # the Free Software Foundation; either version 2, or (at your option)
  12. # any later version.
  13. #
  14. # RCS is distributed in the hope that it will be useful,
  15. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. # GNU General Public License for more details.
  18. #
  19. # You should have received a copy of the GNU General Public License
  20. # along with RCS; see the file COPYING.  If not, write to
  21. # the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22. #
  23. # Report problems and direct all questions to:
  24. #
  25. #    rcs-bugs@cs.purdue.edu
  26.  
  27.  
  28. # Standard output should already be directed to "a.h";
  29. # later parts of this procedure need it.
  30. # Standard error can be ignored if a.h is OK,
  31. # and can be inspected for clues otherwise.
  32.  
  33. # The Makefile overrides the following defaults.
  34. : ${RCSPREFIX=/usr/local/bin/}
  35. : ${CC=cc}
  36. : ${CFLAGS=-O}
  37. : ${COMPAT2=0}
  38. : ${DIFF3=${RCSPREFIX}diff3}
  39. : ${DIFF3_A=1}
  40. : ${DIFF3_BIN=1}
  41. : ${DIFF=${RCSPREFIX}diff}
  42. : ${DIFF_FLAGS=-an}
  43. : ${DIFF_L=1}
  44. : ${DIFF_SUCCESS=0} ${DIFF_FAILURE=1} ${DIFF_TROUBLE=2}
  45. : ${ED=/bin/ed}
  46. : ${SENDMAIL='"/usr/lib/sendmail"'}
  47. # : ${LDFLAGS=} ${LDLIBS=} tickles old shell bug
  48.  
  49. C="$CC $CFLAGS"
  50. CL="$CC $CFLAGS $LDFLAGS"
  51. L=$LDLIBS
  52.  
  53. cat <<EOF
  54. /* RCS compile-time configuration */
  55.  
  56.     /* $Id */
  57.  
  58. /*
  59.  * This file is generated automatically.
  60.  * If you edit it by hand your changes may be lost.
  61.  * Instead, please try to fix conf.sh,
  62.  * and send your fixes to rcs-bugs@cs.purdue.edu.
  63.  */
  64.  
  65. EOF
  66.  
  67. echo >&3 $0: testing compiler for plausibility
  68. echo 'this is not a C source file' >a.c
  69. rm -f a.exe a.out || exit
  70. $CL a.c $L >&2 && {
  71.     echo >&2 "C compiler command '$CL a.c $L' succeeds when it should fail."
  72.     exit 1
  73. }
  74.  
  75. echo >&3 $0: configuring exitmain
  76. cat >a.c <<EOF
  77. #include "a.h"
  78. int main(argc,argv) int argc; char **argv; { return argc-1; }
  79. EOF
  80. rm -f a.exe a.out && $CL a.c $L >&2 || exit
  81. if test -f a.out
  82. then aout=./a.out
  83. elif test -f a.exe
  84. then aout=./a.exe
  85. else
  86.     echo >&2 "C compiler creates neither a.out nor a.exe."
  87.     exit 1
  88. fi
  89. e='exit(n), 3 /* lint fodder */'
  90. if $aout -
  91. then :
  92. elif $aout
  93. then e=n
  94. fi
  95. echo "#define exitmain(n) return $e /* how to exit from main() */"
  96.  
  97. : RM
  98. RM="rm -f $aout"
  99.  
  100. echo >&3 $0: configuring _POSIX_SOURCE
  101. cat >a.c <<'EOF'
  102. #include "a.h"
  103. #include <stdio.h>
  104. int main() {
  105. #    ifdef fileno
  106. #        define f(x) fileno(x)
  107. #    else
  108.         /* Force a compile-time error if fileno isn't declared.  */
  109.         int (*p)() = fileno;
  110. #        define f(x) (*p)(x)
  111. #    endif
  112.     /* Some buggy linkers seem to need the getchar.  */
  113.     exitmain(getchar() != '#' || fileno(stdout) < 0);
  114. }
  115. EOF
  116. a='/* ' z='*/ '
  117. $RM || exit
  118. if ($CL a.c $L && $aout <a.c) >&2
  119. then :
  120. elif $RM || exit; ($CL -D_POSIX_SOURCE a.c $L && $aout <a.c) >&2
  121. then a= z=
  122. fi
  123. cat <<EOF
  124. $a#define _POSIX_SOURCE $z/* Define this if Posix + strict Standard C.  */
  125.  
  126. #include <errno.h>
  127. #include <stdio.h>
  128. #include <time.h>
  129. EOF
  130.  
  131. cat <<'EOF'
  132.  
  133. /* Comment out #include lines below that do not work.  */
  134. EOF
  135.  
  136. # Run `$CS a.c $LS' instead of `$CL a.c $L' for compile-time checking only.
  137. # This speeds up the configuration process.
  138. if rm -f a.s && $C -S a.c >&2 && test -f a.s
  139. then CS="$C -S" LS=    # Generate assembly language output.
  140. elif rm -f a.o a.obj && $C -c a.c >&2 && { test -f a.o || test -f a.obj; }
  141. then CS="$C -c" LS=    # Generate object code.
  142. else CS=$CL LS=$L    # Generate an executable.
  143. fi
  144.  
  145. # standard include files
  146. # sys/types.h and sys/stat.h must come first because others depend on them.
  147. has_signal=1
  148. for h in \
  149.     sys/types sys/stat \
  150.     dirent fcntl limits pwd signal stdlib string sys/mman sys/wait unistd utime vfork
  151. do
  152.     i="#include <$h.h>"
  153.     echo >&3 $0: configuring $i
  154.     cat >a.c <<EOF
  155. #include "a.h"
  156. $i
  157. int main(){ exitmain(0); }
  158. EOF
  159.     $RM || exit
  160.     ($CL a.c $L && $aout) >&2 || {
  161.         case $h in
  162.         string)
  163.             i='#include <strings.h>';;
  164.         *)
  165.             i="/* $i */"
  166.         esac
  167.         case $h in
  168.         signal) has_signal=0
  169.         esac
  170.     }
  171.     echo "$i"
  172. done
  173.  
  174. cat <<'EOF'
  175.  
  176. /* Define the following symbols to be 1 or 0.  */
  177. EOF
  178.  
  179. # has_sys_*_h
  180. for H in dir param
  181. do
  182.     echo >&3 $0: configuring has_sys_${H}_h
  183.     cat >a.c <<EOF
  184. #include "a.h"
  185. #include <sys/$H.h>
  186. int main() { exitmain(0); }
  187. EOF
  188.     $RM || exit
  189.     if ($CL a.c $L && $aout) >&2
  190.     then h=1
  191.     else h=0
  192.     fi
  193.     echo "#define has_sys_${H}_h $h /* Does #include <sys/$H.h> work?  */"
  194. done
  195.  
  196.  
  197. # We must do NAME_MAX and has_readlink next, because they might generate
  198. # #include directives that affect later definitions.
  199.  
  200. echo >&3 $0: configuring NAME_MAX
  201. cat >a.c <<'EOF'
  202. #include "a.h"
  203. main()
  204. {
  205. #if !defined(NAME_MAX)
  206.     exitmain(1);
  207. #else
  208. #    ifdef O_CREAT
  209. #        define creat0(f) open(f, O_CREAT|O_WRONLY, 0)
  210. #    else
  211. #        define creat0(f) creat(f, 0)
  212. #    endif
  213.     int i;
  214.     char b[NAME_MAX + 2];
  215.     b[0] = 'a'; b[1] = '.';
  216.     for (i = 2;  i < NAME_MAX;  i++)
  217.         b[i] = 'a';
  218.     b[i++] = 'b';
  219.     b[i] = 0;
  220.     exitmain(creat0(b) < 0);
  221. #endif
  222. }
  223. EOF
  224. $RM a.*ab || exit
  225. if $CL a.c $L >&2 && $aout && test -f a.*ab
  226. then a= z=
  227. else a='/* ' z='*/ '
  228. fi
  229. rm -f a.*ab || exit
  230.  
  231. echo >&3 $0: configuring has_readlink, readlink_isreg_errno
  232. cat >a.c <<'EOF'
  233. #include "a.h"
  234. char b[7];
  235. int main()
  236. {
  237.     if (readlink("a.sym2",b,7) == 6  &&  strcmp(b,"a.sym1") == 0  &&
  238.         readlink("a.c",b,7) == -1  &&  errno != ENOENT
  239.     ) {
  240.         printf("%d", errno);
  241.         exitmain(0);
  242.     }
  243.     exitmain(1);
  244. }
  245. EOF
  246. $RM a.sym* || exit
  247. readlink_isreg_errno='?'
  248. if (ln -s a.sym1 a.sym2 && $CL a.c $L) >&2 && readlink_isreg_errno=`$aout`
  249. then h=1
  250. else h=0
  251. fi
  252. cat <<EOF
  253. #define has_readlink $h /* Does readlink() work?  */
  254. #define readlink_isreg_errno $readlink_isreg_errno /* errno after readlink on regular file */
  255.  
  256. $a#undef NAME_MAX $z/* Uncomment this if NAME_MAX is broken.  */
  257.  
  258. #if !defined(NAME_MAX) && !defined(_POSIX_NAME_MAX)
  259. #    if has_sys_dir_h
  260. #        include <sys/dir.h>
  261. #    endif
  262. #    ifndef NAME_MAX
  263. #        ifndef MAXNAMLEN
  264. #            define MAXNAMLEN 14
  265. #        endif
  266. #        define NAME_MAX MAXNAMLEN
  267. #    endif
  268. #endif
  269. #if !defined(PATH_MAX) && !defined(_POSIX_PATH_MAX)
  270. #    if has_sys_param_h
  271. #        include <sys/param.h>
  272. #        define included_sys_param_h 1
  273. #    endif
  274. #    ifndef PATH_MAX
  275. #        ifndef MAXPATHLEN
  276. #            define MAXPATHLEN 1024
  277. #        endif
  278. #        define PATH_MAX (MAXPATHLEN-1)
  279. #    endif
  280. #endif
  281. #if has_readlink && !defined(MAXSYMLINKS)
  282. #    if has_sys_param_h && !included_sys_param_h
  283. #        include <sys/param.h>
  284. #    endif
  285. #    ifndef MAXSYMLINKS
  286. #        define MAXSYMLINKS 20 /* BSD; not standard yet */
  287. #    endif
  288. #endif
  289. EOF
  290.  
  291. # *_t
  292. cat <<'EOF'
  293.  
  294. /* Comment out the typedefs below if the types are already declared.  */
  295. /* Fix any uncommented typedefs that are wrong.  */
  296. EOF
  297. cat >a.c <<'EOF'
  298. #include "a.h"
  299. t x;
  300. int main() { exitmain(0); }
  301. EOF
  302. for t in mode_t pid_t sig_atomic_t size_t ssize_t time_t uid_t
  303. do
  304.     echo >&3 $0: configuring $t
  305.     case $t in
  306.     size_t) i=unsigned;;
  307.     time_t) i=long;;
  308.     *) i=int;;
  309.     esac
  310.     if $CS -Dt=$t a.c $LS >&2
  311.     then a='/* ' z=' */'
  312.     else a= z=
  313.     fi
  314.     echo "${a}typedef $i $t;$z"
  315. done
  316.  
  317. cat <<'EOF'
  318.  
  319. /* Comment out the keyword definitions below if the keywords work.  */
  320. EOF
  321.  
  322. for i in const volatile
  323. do
  324.     echo >&3 $0: configuring $i
  325.     cat >a.c <<EOF
  326. #    include "a.h"
  327.     int main();
  328.     enum Boolean { false, true };
  329.     int id();
  330.     static enum Boolean $i zero;
  331.     int id(x) int x; { return x; }  /* HP-UX 8.05 barfs on this.  */
  332.     static enum Boolean $i * $i azero = &zero;
  333.     static enum Boolean $i * $i * $i aazero = &azero;
  334.     static enum Boolean * $i arzero[1];
  335.     static sig_atomic_t $i sigzero;
  336.     int main() {
  337.         enum Boolean *p = arzero[sigzero];
  338.         switch (zero) {
  339.             case false: exitmain(!p || **aazero);
  340.             default: exitmain(id(1));
  341.         }
  342.     }
  343. EOF
  344.     a= z=
  345.     if $CS a.c $LS >&2
  346.     then
  347.         cat >a.c <<EOF
  348.             typedef unsigned char $i *Iptr_type;
  349.             struct { Iptr_type lim; } s, *f = &s;
  350.             int main() {
  351.                 Iptr_type lim;
  352.                 lim = f->lim;
  353.                 return !!lim;
  354.             }
  355. EOF
  356.         if $CS a.c $LS >&2
  357.         then
  358.             case $i in
  359.             const)
  360.                 # Check for common execv misdeclaration.
  361.                 cat >a.c <<EOF
  362.                     char *const *p;
  363.                     int main() { return execv("/bin/sh", p); }
  364. EOF
  365.                 $CS a.c $LS >&2
  366.             esac && a='/* ' z=' */'
  367.         fi
  368.     fi
  369.     echo "$a#define $i$z"
  370. done
  371.  
  372. echo >&3 $0: configuring has_prototypes, has_stdarg, has_varargs, va_start_args
  373. cat >a.ha <<'EOF'
  374. #if has_prototypes
  375. #    define P(params) params
  376. #else
  377. #    define P(params) ()
  378. #endif
  379. #if has_stdarg
  380. #    include <stdarg.h>
  381. #else
  382. #    if has_varargs
  383. #        include <varargs.h>
  384. #    else
  385.         typedef char *va_list;
  386. #        define va_dcl int va_alist;
  387. #        define va_start(ap) ((ap) = (va_list)&va_alist)
  388. #        define va_arg(ap,t) (((t*) ((ap)+=sizeof(t)))  [-1])
  389. #        define va_end(ap)
  390. #    endif
  391. #endif
  392. #if va_start_args == 2
  393. #    define vararg_start va_start
  394. #else
  395. #    define vararg_start(ap,p) va_start(ap)
  396. #endif
  397. EOF
  398. cat >a.c <<'EOF'
  399. #include "a.h"
  400. #include "a.ha"
  401.  
  402. struct buf { int x; };
  403. int pairnames P((int,char**,FILE*(*)P((struct buf*,struct stat*,int)),int,int)); /* a la rcsbase.h */
  404. FILE *(*rcsopen)P((struct buf*,struct stat*,int));  /* a la rcsfnms.c */
  405.  
  406. char *e(p,i) char **p; int i; { return p[i]; }
  407. #if has_prototypes
  408. char *f(char *(*g)(char**,int), char **p, ...)
  409. #else
  410. char *f(g, p, va_alist) char *(*g)(); char **p; va_dcl
  411. #endif
  412. {
  413.     char *s;
  414.     va_list v;
  415.     vararg_start(v,p);
  416.     s = g(p, va_arg(v,int));
  417.     va_end(v);
  418.     return s;
  419. }
  420. int main P((int, char**));
  421. int main(argc, argv) int argc; char **argv; {
  422.     exitmain(f(e,argv,0) != argv[0]  ||  f(e,argv,1) != argv[1]);
  423. }
  424. EOF
  425. for has_prototypes in 1 0
  426. do
  427.     for has_stdarg in 1 v 0
  428.     do
  429.         case $has_stdarg in
  430.         v) has_varargs=1 has_stdarg=0;;
  431.         *) has_varargs=0
  432.         esac
  433.         case $has_stdarg in
  434.         0) as='1 2';;
  435.         1) as='2 1'
  436.         esac
  437.         for va_start_args in $as
  438.         do
  439.             $RM || exit
  440.             $CL \
  441.                 -Dhas_prototypes=$has_prototypes \
  442.                 -Dhas_stdarg=$has_stdarg \
  443.                 -Dhas_varargs=$has_varargs \
  444.                 -Dva_start_args=$va_start_args \
  445.                 a.c $L >&2 && $aout && break
  446.         done && break
  447.     done && break
  448. done || {
  449.     echo >&2 "cannot deduce has_prototypes, has_stdarg, va_start_args"
  450.     exit 1
  451. }
  452. cat - a.ha <<EOF
  453.  
  454. /* Define the following symbols to be 1 or 0.  */
  455. #define has_prototypes $has_prototypes /* Do function prototypes work?  */
  456. #define has_stdarg $has_stdarg /* Does <stdarg.h> work?  */
  457. #define has_varargs $has_varargs /* Does <varargs.h> work?  */
  458. #define va_start_args $va_start_args /* How many args does va_start() take?  */
  459. EOF
  460.  
  461. echo >&3 $0: configuring text_equals_binary_stdio, FOPEN_...
  462. cat >a.c <<'EOF'
  463. #include "a.h"
  464.     int
  465. copy(from, to, mode)
  466.     char const *from, *to, *mode;
  467. {
  468.     int c;
  469.     FILE *f, *g;
  470.     if (!(f = fopen(from, "rb")) || !(g = fopen(to, mode)))
  471.         return 1;
  472.     while (c=getc(f), !feof(f))
  473.         if (ferror(f)  ||  putc(c,g)<0 && ferror(g))
  474.             return 1;
  475.     return fclose(f)!=0 || fclose(g)!=0;
  476. }
  477.     int
  478. main(argc, argv)
  479.     char **argv;
  480. {
  481.     exitmain(copy(argv[1], "a.d", "w+b") || copy(argv[1], "a.e", "w+"));
  482. }
  483. EOF
  484. e=1
  485. $RM && $CL a.c $L || exit
  486. for i in a.c $aout
  487. do
  488.     rm -f a.d a.e || exit
  489.     $aout $i  &&  cmp $i a.d >&2  &&  { cmp $i a.e >&2 || { e=0; break; }; }
  490. done
  491. cat <<EOF
  492.  
  493. #define text_equals_binary_stdio $e /* Does stdio treat text like binary?  */
  494. #define text_work_stdio 0 /* Text i/o for working file, binary for RCS file?  */
  495. #if text_equals_binary_stdio
  496.     /* Text and binary i/o behave the same, or binary i/o does not work.  */
  497. #    define FOPEN_R "r"
  498. #    define FOPEN_W "w"
  499. #    define FOPEN_WPLUS "w+"
  500. #    define OPEN_O_BINARY 0
  501. #else
  502.     /* Text and binary i/o behave differently.  */
  503.     /* This is incompatible with Posix and Unix.  */
  504. #    define FOPEN_R "rb"
  505. #    define FOPEN_W "wb"
  506. #    define FOPEN_WPLUS "w+b"
  507. #    define OPEN_O_BINARY O_BINARY
  508. #    ifndef O_BINARY
  509. #    define O_BINARY 0
  510. #    endif
  511. #endif
  512. #if text_work_stdio
  513. #    define FOPEN_R_WORK "r"
  514. #    define FOPEN_W_WORK "w"
  515. #    define FOPEN_WPLUS_WORK "w+"
  516. #    define OPEN_O_WORK 0
  517. #else
  518. #    define FOPEN_R_WORK FOPEN_R
  519. #    define FOPEN_W_WORK FOPEN_W
  520. #    define FOPEN_WPLUS_WORK FOPEN_WPLUS
  521. #    define OPEN_O_WORK OPEN_O_BINARY
  522. #endif
  523.  
  524. /* Define or comment out the following symbols as needed.  */
  525. EOF
  526.  
  527. echo >&3 $0: configuring bad_chmod_close
  528. cat >a.c <<'EOF'
  529. #include "a.h"
  530. #ifndef O_RDONLY
  531. #    define O_RDONLY 0
  532. #endif
  533. int main() {
  534.     int f;
  535.     exitmain(
  536.         (f = open("a.c", O_RDONLY)) < 0 ||
  537.         chmod("a.c", 0) != 0 ||
  538.         close(f) != 0
  539.     );
  540. }
  541. EOF
  542. $RM || exit
  543. if $CL a.c $L >&2 && $aout
  544. then b=0
  545. else b=1
  546. fi
  547. echo "#define bad_chmod_close $b /* Can chmod() close file descriptors?  */"
  548. rm -f a.c || exit
  549.  
  550. echo >&3 $0: configuring bad_creat0
  551. cat >a.c <<'EOF'
  552. #include "a.h"
  553. #ifdef O_CREAT
  554. #    define creat0(f) open(f, O_CREAT|O_WRONLY, 0)
  555. #else
  556. #    define creat0(f) creat(f, 0)
  557. #endif
  558. char buf[17000];
  559. int main() {
  560.     int f;
  561.     exitmain(
  562.         (f = creat0("a.d")) < 0  ||
  563.         write(f, buf, sizeof(buf)) != sizeof(buf) ||
  564.         close(f) != 0
  565.     );
  566. }
  567. EOF
  568. $RM a.d || exit
  569. if $CL a.c $L >&2 && $aout && test -f a.d && test ! -w a.d
  570. then b=0
  571. else b=1
  572. fi
  573. echo "#define bad_creat0 $b /* Do writes fail after creat(f,0)?  */"
  574. rm -f a.d || exit
  575.  
  576. echo >&3 $0: configuring bad_fopen_wplus
  577. cat >a.c <<'EOF'
  578. #include "a.h"
  579. int main() { exitmain(!fopen("a.d",FOPEN_WPLUS)); }
  580. EOF
  581. $RM || exit
  582. if echo nonempty >a.d && $CL a.c $L >&2 && $aout && test ! -s a.d
  583. then b=0
  584. else b=1
  585. fi
  586. echo "#define bad_fopen_wplus $b /* Does fopen(f,FOPEN_WPLUS) fail to truncate f?  */"
  587.  
  588. echo "#define getlogin_is_secure 0 /* Is getlogin() secure?  Usually it's not.  */"
  589.  
  590. echo >&3 $0: configuring has_dirent
  591. cat >a.c <<'EOF'
  592. #include "a.h"
  593. int main() {
  594.     DIR *d = opendir(".");
  595.     struct dirent *e;
  596.     while ((e = readdir(d)))
  597.         if (strcmp(e->d_name, "a.c") == 0  &&  closedir(d) == 0)
  598.             exitmain(0);
  599.     exitmain(1);
  600. }
  601. EOF
  602. $RM || exit
  603. if $CL a.c $L >&2 && $aout
  604. then h=1
  605. else h=0
  606. fi
  607. echo "#define has_dirent $h /* Do opendir(), readdir(), closedir() work?  */"
  608.  
  609. echo >&3 $0: configuring has_fchmod
  610. cat >a.c <<'EOF'
  611. #include "a.h"
  612. int main() { exitmain(fchmod(fileno(stdin),0) != 0); }
  613. EOF
  614. $RM || exit
  615. if $CL a.c $L >&2 && $aout <a.c && test ! -r a.c
  616. then h=1
  617. else h=0
  618. fi
  619. echo "#define has_fchmod $h /* Does fchmod() work?  */"
  620. rm -f a.c || exit
  621.  
  622. echo >&3 $0: configuring has_fputs
  623. cat >a.c <<'EOF'
  624. #include "a.h"
  625. int main() { exitmain(fputs("Hello\"\nworld", stdout) != 12); }
  626. EOF
  627. Hello='Hello"
  628. world'
  629. $RM a.a || exit
  630. if $CL a.c $L >&2 && $aout >a.a && x=`$aout` && test " $x" = " $Hello"
  631. then h=1
  632. else h=0
  633. fi
  634. echo "#define has_fputs $h /* Does fputs() work?  */"
  635.  
  636. echo >&3 $0: configuring has_ftruncate
  637. cat >a.c <<'EOF'
  638. #include "a.h"
  639. #ifdef O_CREAT
  640. #    define creat0(f) open(f, O_CREAT|O_WRONLY, 0)
  641. #else
  642. #    define creat0(f) creat(f, 0)
  643. #endif
  644. int main(argc, argv) int argc; char **argv; {
  645.     int f = creat0(argv[1]);
  646.     if (f<0 || write(f,"abc",3)!=3 || ftruncate(f,(off_t)0)!=0 || close(f)!=0)
  647.             exitmain(1);
  648.     exitmain(0);
  649. }
  650. EOF
  651. $RM || exit
  652. if $CL a.c $L >&2
  653. then
  654.     h=1
  655.     # Check out /tmp too; it's buggy on some hosts.
  656.     for d in . /tmp
  657.     do
  658.         if test -d $d
  659.         then
  660.             f=$d/a.d
  661.             rm -f $f || exit
  662.             $aout $f && test ! -s $f && test -f $f  ||  { h=0; break; }
  663.             rm -f $f || exit
  664.         fi
  665.     done
  666. else h=0
  667. fi
  668. echo "#define has_ftruncate $h /* Does ftruncate() work?  */"
  669.  
  670. echo >&3 $0: configuring has_getuid
  671. cat >a.c <<'EOF'
  672. #include "a.h"
  673. #ifndef getuid
  674.     uid_t getuid();
  675. #endif
  676. int main() { exitmain(getuid()!=getuid()); }
  677. EOF
  678. $RM || exit
  679. if ($CL a.c $L && $aout) >&2
  680. then has_getuid=1
  681. else has_getuid=0
  682. fi
  683. echo "#define has_getuid $has_getuid /* Does getuid() work?  */"
  684.  
  685. echo >&3 $0: configuring has_getpwuid
  686. case $has_getuid in
  687. 0)
  688.     a='/* ' z='*/ ' h=?;;
  689. *)
  690.     a= z=
  691.     cat >a.c <<'EOF'
  692. #include "a.h"
  693. int main() { exitmain(!getpwuid(0)); }
  694. EOF
  695.     $RM || exit
  696.     if ($CL a.c $L && $aout) >&2
  697.     then h=1
  698.     else h=0
  699.     fi
  700. esac
  701. echo "$a#define has_getpwuid $h $z/* Does getpwuid() work?  */"
  702.  
  703. echo >&3 $0: configuring has_kill
  704. cat >a.c <<'EOF'
  705. #include "a.h"
  706. #ifndef getpid
  707.     pid_t getpid();
  708. #endif
  709. int main() { exitmain(kill(getpid(), 0) != 0); }
  710. EOF
  711. $RM || exit
  712. if ($CL a.c $L && $aout) >&2
  713. then has_kill=1
  714. else has_kill=0
  715. fi
  716. # Used only by this script, not by RCS, so we don't output it.
  717.  
  718. echo >&3 $0: configuring has_memcmp
  719. cat >a.c <<'EOF'
  720. #include "a.h"
  721. int main() { exitmain(memcmp("beautiful","beautiful",10) != 0); }
  722. EOF
  723. $RM || exit
  724. if ($CL a.c $L && $aout) >&2
  725. then h=1
  726. else h=0
  727. fi
  728. echo "#define has_memcmp $h /* Does memcmp() work?  */"
  729.  
  730. echo >&3 $0: configuring has_memcpy
  731. cat >a.c <<'EOF'
  732. #include "a.h"
  733. char a[3];
  734. int main() {
  735.     memcpy(a,"xy",3);
  736.     exitmain(strcmp(a,"xy")!=0);
  737. }
  738. EOF
  739. $RM || exit
  740. if ($CL a.c $L && $aout) >&2
  741. then h=1
  742. else h=0
  743. fi
  744. echo "#define has_memcpy $h /* Does memcpy() work?  */"
  745.  
  746. echo >&3 $0: configuring has_memmove
  747. cat >a.c <<'EOF'
  748. #include "a.h"
  749. char a[4];
  750. int main() {
  751.     strcpy(a, "xy");
  752.     memmove(a+1, a, 3);
  753.     exitmain(strcmp(a,"xxy")!=0);
  754. }
  755. EOF
  756. $RM || exit
  757. if ($CL a.c $L && $aout) >&2
  758. then h=1
  759. else h=0
  760. fi
  761. echo "#define has_memmove $h /* Does memmove() work?  */"
  762.  
  763. echo >&3 $0: configuring has_mmap, has_madvise, caddr_t
  764. cat >a.c <<'EOF'
  765. #include "a.h"
  766. int main() { exitmain(getpagesize() <= 0); }
  767. EOF
  768. $RM || exit
  769. if ($CL a.c $L && $aout) >&2
  770. then has_getpagesize=1
  771. else has_getpagesize=0
  772. fi
  773. cat >a.c <<'EOF'
  774. #define CHAR1 '#' /* the first character in this file */
  775. #include "a.h"
  776. #if !has_caddr_t
  777.     typedef char *caddr_t;
  778. #endif
  779. caddr_t a;
  780. struct stat b;
  781. #ifndef MADVISE_OK
  782. #define MADVISE_OK (madvise(a,b.st_size,MADV_SEQUENTIAL)==0 && madvise(a,b.st_size,MADV_NORMAL)==0)
  783. #endif
  784. #if !has_getpagesize
  785. #define getpagesize() (1024 * 1024L) /* should be big enough */
  786. #endif
  787. #ifndef WTERMSIG
  788. #define WTERMSIG(s) ((s)&0177)
  789. #undef WIFSIGNALED /* Avoid 4.3BSD incompatibility with Posix.  */
  790. #endif
  791. #ifndef WIFSIGNALED
  792. #define WIFSIGNALED(s) (((s)&0377) != 0177  &&  WTERMSIG(s) != 0)
  793. #endif
  794. int main(argc, argv)
  795.     char **argv;
  796. {
  797.     int extra_bytes = 1<argc ? getpagesize() : 0;
  798.     int s = 0;
  799.     if (fstat(fileno(stdin), &b) != 0)
  800.         exitmain(1);
  801.     a = mmap(
  802.         (caddr_t)0, b.st_size + extra_bytes, PROT_READ, MAP_SHARED,
  803.         fileno(stdin), (off_t)0
  804.     );
  805.     if (a == (caddr_t)-1  ||  !MADVISE_OK  ||  *a != CHAR1)
  806.         exitmain(1);
  807.     if (1 < argc) {
  808.         pid_t p = fork();
  809.         if (p < 0)
  810.             exitmain(1);
  811.         if (p == 0)
  812.             /* Refer to nonexistent storage, causing a signal in the child.  */
  813.             exitmain(a[b.st_size + extra_bytes - 1] == 0);
  814.         if (wait(&s) != p  ||  ! WIFSIGNALED(s)  ||  WTERMSIG(s) == 0)
  815.             exitmain(1);
  816.     }
  817.     if (munmap(a, b.st_size)  !=  0)
  818.         exitmain(1);
  819.     if (1 < argc)
  820.         printf("%d\n", WTERMSIG(s));
  821.     exitmain(fclose(stdout) != 0);
  822. }
  823. EOF
  824. a=0 has_mmap=0 mmap_signal=
  825. for has_caddr_t in 1 0
  826. do
  827.     $RM || exit
  828.     if (
  829.         $CL -Dhas_caddr_t=$has_caddr_t -Dhas_getpagesize=$has_getpagesize \
  830.             -DMADVISE_OK=1 a.c $L && $aout <a.c
  831.     ) >&2
  832.     then
  833.         has_mmap=1
  834.         mmap_signal=`$aout - <a.c`
  835.         $RM || exit
  836.         ($CL -Dhas_caddr_t=$has_caddr_t a.c $L && $aout <a.c) >&2 && a=1
  837.         break
  838.     fi
  839. done
  840. echo "#define has_madvise $a /* Does madvise() work?  */"
  841. echo "#define has_mmap $has_mmap /* Does mmap() work on regular files?  */"
  842. case $has_caddr_t,$has_mmap in
  843. 0,1) a= z=;;
  844. *) a='/* ' z='*/ '
  845. esac
  846. echo "${a}typedef char *caddr_t; $z/* mmap argument type */"
  847. case $mmap_signal in
  848. ?*) a= z=;;
  849. '') a='/* ' z='*/ ' mmap_signal='?'
  850. esac
  851. echo "$a#define mmap_signal $mmap_signal $z/* signal received if you reference nonexistent part of mmapped file */"
  852.  
  853. echo >&3 $0: configuring has_rename, bad_a_rename, bad_b_rename
  854. cat >a.c <<'EOF'
  855. #include "a.h"
  856. int main() { exitmain(rename("a.a","a.b") != 0); }
  857. EOF
  858. echo a >a.a && $RM a.b || exit
  859. if ($CL a.c $L && $aout && test -f a.b) >&2
  860. then
  861.     h=1
  862.     rm -f a.a a.b &&
  863.     echo a >a.a && chmod -w a.a || exit
  864.     if $aout && test ! -f a.a && test -f a.b
  865.     then a=0
  866.     else a=1
  867.     fi
  868.     rm -f a.a a.b &&
  869.     echo a >a.a && echo b >a.b && chmod -w a.b || exit
  870.     if $aout && test ! -f a.a && test -f a.b
  871.     then b=0
  872.     else b=1
  873.     fi
  874.     rm -f a.a a.b || exit
  875. else h=0 a=0 b=0
  876. fi
  877. echo "#define has_rename $h /* Does rename() work?  */"
  878. echo "#define bad_a_rename $a /* Does rename(A,B) fail if A is unwritable?  */"
  879. echo "#define bad_b_rename $b /* Does rename(A,B) fail if B is unwritable?  */"
  880.  
  881. echo >&3 $0: configuring void, VOID
  882. cat >a.c <<'EOF'
  883. #include "a.h"
  884. void f() {}
  885. int main() {f(); exitmain(0);}
  886. EOF
  887. if $CS a.c $LS >&2
  888. then
  889.     v='(void) '
  890.     echo '/* typedef int void; */ /* Some ancient compilers need this.  */'
  891. else
  892.     v=
  893.     echo 'typedef int void;'
  894. fi
  895. echo "#define VOID $v/* 'VOID e;' discards the value of an expression 'e'.  */"
  896.  
  897. echo >&3 $0: configuring has_seteuid
  898. case $has_getuid in
  899. 0)
  900.     a='/* ' z='*/ ' has_seteuid=?;;
  901. *)
  902.     a= z=
  903.     cat >a.c <<'EOF'
  904. #include "a.h"
  905. #ifndef geteuid
  906.     uid_t geteuid();
  907. #endif
  908. int main() {
  909. /* Guess, don't test.  Ugh.  Testing would require running conf.sh setuid.  */
  910. /* If the guess is wrong, a setuid RCS will detect the problem at runtime.  */
  911. #if !_POSIX_VERSION
  912.     exitmain(1);
  913. #else
  914.     exitmain(seteuid(geteuid()) != 0);
  915. #endif
  916. }
  917. EOF
  918.     $RM || exit
  919.     if ($CL a.c $L && $aout) >&2
  920.     then has_seteuid=1
  921.     else has_seteuid=0
  922.     fi
  923. esac
  924. echo "$a#define has_seteuid $has_seteuid $z/* Does seteuid() work?  See README.  */"
  925.  
  926. echo >&3 $0: configuring has_setuid
  927. h=$has_seteuid
  928. case $h in
  929. 0)
  930.     cat >a.c <<'EOF'
  931. #include "a.h"
  932. #ifndef getuid
  933.     uid_t getuid();
  934. #endif
  935. int main() { exitmain(setuid(getuid()) != 0); }
  936. EOF
  937.     $RM || exit
  938.     ($CL a.c $L && $aout) >&2 && h=1
  939. esac
  940. echo "$a#define has_setuid $h $z/* Does setuid() exist?  */"
  941.  
  942. echo >&3 $0: configuring has_signal, signal_args, signal_type, sig_zaps_handler
  943. cat >a.c <<'EOF'
  944. #include "a.h"
  945. #if has_kill && !defined(getpid)
  946.     pid_t getpid();
  947. #endif
  948. #if !defined(signal) && declare_signal
  949.     signal_type (*signal P((int,signal_type(*)signal_args)))signal_args;
  950. #endif
  951. signal_type nothing(i) int i; {}
  952. int main(argc, argv) int argc; char **argv;
  953. {
  954.     signal(SIGINT, nothing);
  955. #    if has_kill
  956.         while (--argc)
  957.             kill(getpid(), SIGINT);
  958.         exitmain(0);
  959. #    else
  960.         /* Pretend that sig_zaps_handler; better safe than sorry.  */
  961.         exitmain(2 < argc);
  962. #    endif
  963. }
  964. EOF
  965. for declare_signal in 1 0
  966. do
  967.     for signal_type in void int
  968.     do
  969.         for signal_args in 'P((int))' '()'
  970.         do
  971.             $RM || exit
  972.             ($CL \
  973.                 -Ddeclare_signal=$declare_signal \
  974.                 -Dhas_kill=$has_kill \
  975.                 -Dsignal_args="$signal_args" \
  976.                 -Dsignal_type=$signal_type \
  977.                     a.c $L && $aout 1) >&2 && break
  978.         done && break
  979.     done && break
  980. done || {
  981.     echo >&2 "cannot deduce signal_args, signal_type"
  982.     exit 1
  983. }
  984. if $aout 1 2 >&2
  985. then z=0
  986. else z=1
  987. fi
  988. cat <<EOF
  989. #define has_signal $has_signal /* Does signal() work?  */
  990. #define signal_args $signal_args /* arguments of signal handlers */
  991. #define signal_type $signal_type /* type returned by signal handlers */
  992. #define sig_zaps_handler $z /* Must a signal handler reinvoke signal()?  */
  993. EOF
  994.  
  995. echo >&3 $0: configuring has_sigaction
  996. cat >a.c <<'EOF'
  997. #include "a.h"
  998. #ifndef getpid
  999.     pid_t getpid();
  1000. #endif
  1001. static sig_atomic_t volatile gotsig;
  1002. static void getsig(i) int i; { gotsig = 1; }
  1003. int main(argc, argv) int argc; char **argv;
  1004. {
  1005.     struct sigaction s;
  1006.     sigset_t t;
  1007.     if (sigemptyset(&t) != 0  ||  sigaddset(&t, SIGINT) != 0)
  1008.         exitmain(1);
  1009.     if (sigaction(SIGINT, (struct sigaction*)0, &s) != 0)
  1010.         exitmain(1);
  1011.     s.sa_handler = getsig;
  1012.     s.sa_mask = t;
  1013.     if (sigaction(SIGINT, &s, (struct sigaction*)0) != 0)
  1014.         exitmain(1);
  1015. #    if has_kill
  1016.         kill(getpid(), SIGINT);
  1017. #    else
  1018.         raise(SIGINT);
  1019. #    endif
  1020.     exitmain(gotsig != 1);
  1021. }
  1022. EOF
  1023. $RM || exit
  1024. if ($CL -Dhas_kill=$has_kill a.c $L && $aout) >&2
  1025. then has_sigaction=1
  1026. else has_sigaction=0
  1027. fi
  1028. echo "#define has_sigaction $has_sigaction /* Does struct sigaction work?  */"
  1029.  
  1030. echo >&3 $0: configuring has_sigblock, sigmask
  1031. a='/* ' z='*/ '
  1032. b='/* ' y='*/ '
  1033. case $has_sigaction in
  1034. 1)
  1035.     h=? n=?;;
  1036. *)
  1037.     a= z=
  1038.     cat >a.c <<'EOF'
  1039. #include "a.h"
  1040. #include <signal.h>
  1041. #if define_sigmask
  1042. #    define sigmask(s) (1 << ((s)-1))
  1043. #endif
  1044. int main()
  1045. {
  1046.     sigblock(sigmask(SIGHUP));
  1047. #    if has_kill
  1048.         exitmain(kill(getpid(), SIGHUP) != 0);
  1049. #    else
  1050.         exitmain(raise(SIGHUP) != 0);
  1051. #    endif
  1052. }
  1053. EOF
  1054.     if $RM || exit; ($CL -Dhas_kill=$has_kill a.c $L && $aout) >&2
  1055.     then h=1
  1056.     elif $RM || exit; ($CL -Dhas_kill=$has_kill -Ddefine_sigmask=1 a.c $L && $aout) >&2
  1057.     then h=1 b= y=
  1058.     else h=0
  1059.     fi
  1060. esac
  1061. echo "$a#define has_sigblock $h $z/* Does sigblock() work?  */"
  1062. echo "$b#define sigmask(s) (1 << ((s)-1)) $y/* Yield mask for signal number.  */"
  1063.  
  1064. echo >&3 $0: configuring has_sys_siglist
  1065. cat >a.c <<'EOF'
  1066. #include "a.h"
  1067. #ifndef sys_siglist
  1068.     extern char const *sys_siglist[];
  1069. #endif
  1070. int main() { exitmain(!sys_siglist[1][0]); }
  1071. EOF
  1072. $RM || exit
  1073. if ($CL a.c $L && $aout) >&2
  1074. then h=1
  1075. else h=0
  1076. fi
  1077. echo "#define has_sys_siglist $h /* Does sys_siglist[] work?  */"
  1078.  
  1079. echo >&3 $0: configuring fread_type, Fread, Fwrite
  1080. cat >a.c <<'EOF'
  1081. #define CHAR1 '#' /* the first character in this file */
  1082. #include "a.h"
  1083. #if !defined(fread) && declare_fread
  1084.     fread_type fread P((void*,freadarg_type,freadarg_type,FILE*));
  1085. #endif
  1086. int main()
  1087. {
  1088.     char b;
  1089.     exitmain(!(
  1090.         fread(&b, (freadarg_type)1, (freadarg_type)1, stdin) == 1  &&
  1091.         b==CHAR1
  1092.     ));
  1093. }
  1094. EOF
  1095. for declare_fread in 1 0
  1096. do
  1097.     for fread_type in ssize_t size_t int unsigned
  1098.     do
  1099.         for freadarg_type in size_t ssize_t unsigned int
  1100.         do
  1101.             $RM || exit
  1102.             (
  1103.                 $CL \
  1104.                     -Ddeclare_fread=$declare_fread \
  1105.                     -Dfreadarg_type=$freadarg_type \
  1106.                     -Dfread_type=$fread_type \
  1107.                     a.c $L &&
  1108.                 $aout <a.c
  1109.             ) >&2 && break
  1110.         done && break
  1111.     done && break
  1112. done || {
  1113.     echo >&2 "cannot deduce fread types"
  1114.     exit 1
  1115. }
  1116. cat <<EOF
  1117. typedef $fread_type fread_type; /* type returned by fread() and fwrite() */
  1118. typedef $freadarg_type freadarg_type; /* type of their size arguments */
  1119. EOF
  1120.  
  1121. echo >&3 $0: configuring malloc_type
  1122. cat >a.c <<'EOF'
  1123. #include "a.h"
  1124. typedef void *malloc_type;
  1125. #ifndef malloc
  1126.     malloc_type malloc();
  1127. #endif
  1128. malloc_type identity P((malloc_type));
  1129. malloc_type identity(x) malloc_type x; { return x; }
  1130. int main() { exitmain(!identity(malloc(1))); }
  1131. EOF
  1132. if $CS a.c $LS >&2
  1133. then t=void
  1134. else t=char
  1135. fi
  1136. echo "typedef $t *malloc_type; /* type returned by malloc() */"
  1137.  
  1138. echo >&3 $0: configuring has_getcwd
  1139. cat >a.c <<'EOF'
  1140. #include "a.h"
  1141. #ifndef getcwd
  1142.     char *getcwd();
  1143. #endif
  1144. char buf[10000];
  1145. int main() { exitmain(!getcwd(buf,10000)); }
  1146. EOF
  1147. $RM || exit
  1148. if ($CL a.c $L && $aout) >&2
  1149. then has_getcwd=1
  1150. else has_getcwd=0
  1151. fi
  1152. echo "#define has_getcwd $has_getcwd /* Does getcwd() work?  */"
  1153.  
  1154. echo >&3 $0: configuring has_getwd
  1155. case $has_getcwd in
  1156. 1)
  1157.     a='/* ' z='*/ ' h=?;;
  1158. *)
  1159.     a= z=
  1160.     cat >a.c <<'EOF'
  1161. #include "a.h"
  1162. #include <sys/param.h>
  1163. #ifndef getwd
  1164.     char *getwd();
  1165. #endif
  1166. char buf[MAXPATHLEN];
  1167. int main() { exitmain(!getwd(buf)); }
  1168. EOF
  1169.     $RM || exit
  1170.     if ($CL a.c $L && $aout) >&2
  1171.     then h=1
  1172.     else h=0
  1173.     fi
  1174. esac
  1175. echo "$a#define has_getwd $h $z/* Does getwd() work?  */"
  1176.  
  1177. echo >&3 $0: configuring has_mktemp
  1178. cat >a.c <<'EOF'
  1179. #include "a.h"
  1180. #ifndef mktemp
  1181.     char *mktemp();
  1182. #endif
  1183. int main()
  1184. {
  1185.     char b[9];
  1186.     strcpy(b, "a.XXXXXX");
  1187.     exitmain(!mktemp(b));
  1188. }
  1189. EOF
  1190. $RM || exit
  1191. if ($CL a.c $L && $aout) >&2
  1192. then h=1
  1193. else h=0
  1194. fi
  1195. echo "#define has_mktemp $h /* Does mktemp() work?  */"
  1196.  
  1197. : configuring has_NFS
  1198. echo "#define has_NFS 1 /* Might NFS be used?  */"
  1199.  
  1200. echo >&3 $0: configuring strchr
  1201. cat >a.c <<'EOF'
  1202. #include "a.h"
  1203. #ifndef strchr
  1204.     char *strchr();
  1205. #endif
  1206. int main() {exitmain(!strchr("abc", 'c'));}
  1207. EOF
  1208. $RM || exit
  1209. if ($CL a.c $L && $aout) >&2
  1210. then a='/* ' z='*/ '
  1211. else a= z=
  1212. fi
  1213. echo "$a#define strchr index $z/* Use old-fashioned name for strchr()?  */"
  1214.  
  1215. echo >&3 $0: configuring strrchr
  1216. cat >a.c <<'EOF'
  1217. #include "a.h"
  1218. #ifndef strrchr
  1219.     char *strrchr();
  1220. #endif
  1221. int main() {exitmain(!strrchr("abc", 'c'));}
  1222. EOF
  1223. $RM || exit
  1224. if ($CL a.c $L && $aout) >&2
  1225. then a='/* ' z='*/ '
  1226. else a= z=
  1227. fi
  1228. echo "$a#define strrchr rindex $z/* Use old-fashioned name for strrchr()?  */"
  1229.  
  1230. echo >&3 $0: configuring bad_unlink
  1231. cat >a.c <<'EOF'
  1232. #include "a.h"
  1233. int main() { exitmain(unlink("a.c") != 0); }
  1234. EOF
  1235. $RM && chmod -w a.c || exit
  1236. if ($CL a.c $L && $aout) >&2 && test ! -f a.c
  1237. then b=0
  1238. else b=1
  1239. fi
  1240. rm -f a.c || exit
  1241. echo "#define bad_unlink $b /* Does unlink() fail on unwritable files?  */"
  1242.  
  1243. echo >&3 $0: configuring has_vfork, has_fork, has_spawn, has_wait, has_waitpid, RCS_SHELL
  1244. cat >a.c <<'EOF'
  1245. #include "a.h"
  1246. #ifndef getpid
  1247.     pid_t getpid();
  1248. #endif
  1249. #if TRY_VFORK
  1250. #    ifndef vfork
  1251.         pid_t vfork();
  1252. #    endif
  1253. #else
  1254. #    ifndef fork
  1255.         pid_t fork();
  1256. #    endif
  1257. #    undef vfork
  1258. #    define vfork fork
  1259. #endif
  1260. #if TRY_WAITPID
  1261. #    ifndef waitpid
  1262.         pid_t waitpid();
  1263. #    endif
  1264. #else
  1265. #    ifndef wait
  1266.         pid_t wait();
  1267. #    endif
  1268. #    undef waitpid
  1269. #    define waitpid(p,s,o) wait(s)
  1270. #endif
  1271.  
  1272. int main()
  1273. {
  1274.     pid_t parent = getpid();
  1275.     pid_t child = vfork();
  1276.  
  1277.     if (child == 0) {
  1278.         /*
  1279.          * On sparc systems, changes by the child to local and incoming
  1280.          * argument registers are propagated back to the parent.
  1281.          * The compiler is told about this with #include <vfork.h>,
  1282.          * but some compilers (e.g. gcc -O) don't grok <vfork.h>.
  1283.          * Test for this by using lots of local variables, at least
  1284.          * as many local variables as `main' has allocated so far
  1285.          * including compiler temporaries.  4 locals are enough for
  1286.          * gcc 1.40.3 on a sparc, but we use 8 to be safe.
  1287.          * A buggy compiler should reuse the register of `parent'
  1288.          * for one of the local variables, since it will think that
  1289.          * `parent' can't possibly be used any more in this routine.
  1290.          * Assigning to the local variable will thus munge `parent'
  1291.          * in the parent process.
  1292.          */
  1293.         pid_t
  1294.             p = getpid(),
  1295.             p1 = getpid(), p2 = getpid(),
  1296.             p3 = getpid(), p4 = getpid(),
  1297.             p5 = getpid(), p6 = getpid(),
  1298.             p7 = getpid();
  1299.         /*
  1300.          * Convince the compiler that p..p7 are live; otherwise, it might
  1301.          * use the same hardware register for all 8 local variables.
  1302.          */
  1303.         if (p!=p1 || p!=p2 || p!=p3 || p!=p4 || p!=p5 || p!=p6 || p!=p7)
  1304.             _exit(1);
  1305.  
  1306.         /*
  1307.          * On some systems (e.g. IRIX 3.3),
  1308.          * vfork doesn't separate parent from child file descriptors.
  1309.          * If the child closes a descriptor before it execs or exits,
  1310.          * this munges the parent's descriptor as well.
  1311.          * Test for this by closing stdout in the child.
  1312.          */
  1313.         _exit(close(fileno(stdout)) != 0);
  1314.  
  1315.     } else {
  1316.         int status;
  1317.         struct stat st;
  1318.         while (waitpid(child, &status, 0) != child)
  1319.             ;
  1320.         exit(
  1321.             /* Was there some problem with vforking?  */
  1322.             child < 0
  1323.  
  1324.             /* Did the child fail?  (This shouldn't happen.)  */
  1325.             || status
  1326.  
  1327.             /* Did the vfork/compiler bug occur?  */
  1328.             || parent != getpid()
  1329.  
  1330.             /* Did the file descriptor bug occur?  */
  1331.             || fstat(fileno(stdout), &st) != 0
  1332.         );
  1333.     }
  1334. }
  1335. EOF
  1336. $RM || exit
  1337. if ($CL -DTRY_VFORK=1 a.c $L && $aout) >&2
  1338. then has_vfork=1
  1339. else has_vfork=0
  1340. fi
  1341. echo "#define has_vfork $has_vfork /* Does vfork() work?  */"
  1342. h=$has_vfork
  1343. case $h in
  1344. 0)
  1345.     $RM || exit
  1346.     ($CL a.c $L && $aout) >&2 && h=1
  1347. esac
  1348. echo "#define has_fork $h /* Does fork() work?  */"
  1349. $RM || exit
  1350. if ($CL -DTRY_VFORK=$has_vfork -DTRY_WAITPID=1 a.c $L && $aout) >&2
  1351. then h=1
  1352. else h=0
  1353. fi
  1354. echo "#define has_spawn 0 /* Does spawn*() work?  */"
  1355. echo "#define has_wait 1 /* Does wait() work?  */"
  1356. echo "#define has_waitpid $h /* Does waitpid() work?  */"
  1357. echo '#define RCS_SHELL "/bin/sh" /* shell to run RCS subprograms */'
  1358.  
  1359. echo >&3 $0: configuring has_vfprintf
  1360. cat >a.c <<'EOF'
  1361. #include "a.h"
  1362. #if has_prototypes
  1363. int p(char const*format,...)
  1364. #else
  1365. /*VARARGS1*/ int p(format, va_alist) char *format; va_dcl
  1366. #endif
  1367. {
  1368.     int r;
  1369.     va_list args;
  1370.     vararg_start(args, format);
  1371.     r = vfprintf(stderr, format, args);
  1372.     va_end(args);
  1373.     return r;
  1374. }
  1375. int main() { exitmain(p("") != 0); }
  1376. EOF
  1377. $RM || exit
  1378. if ($CL a.c $L && $aout) >&2
  1379. then h=1
  1380. else h=0
  1381. fi
  1382. echo "#define has_vfprintf $h /* Does vfprintf() work?  */"
  1383.  
  1384. echo >&3 $0: configuring has__doprintf, has__doprnt
  1385. case $h in
  1386. 1)
  1387.     h=? a='/* ' z='*/ ';;
  1388. *)
  1389.     a= z=
  1390.     cat >a.c <<'EOF'
  1391. #include "a.h"
  1392. #if has_prototypes
  1393. int p(char const*format,...)
  1394. #else
  1395. /*VARARGS1*/ int p(format, va_alist) char *format; va_dcl
  1396. #endif
  1397. {
  1398.     va_list args;
  1399.     vararg_start(args, format);
  1400. #    if TRY__DOPRINTF
  1401.         _doprintf(stderr, format, args);
  1402. #    else
  1403.         _doprnt(format, args, stderr);
  1404. #    endif
  1405.     va_end(args);
  1406. }
  1407. int main() { p(""); exitmain(ferror(stderr) != 0); }
  1408. EOF
  1409.     $RM || exit
  1410.     if ($CL -DTRY__DOPRINTF=1 a.c $L && $aout) >&2
  1411.     then h=1
  1412.     else h=0
  1413.     fi
  1414. esac
  1415. echo "$a#define has__doprintf $h $z/* Does _doprintf() work?  */"
  1416. case $h in
  1417. 0)
  1418.     $RM || exit
  1419.     if ($CL a.c $L && $aout) >&2
  1420.     then h=1
  1421.     else h=0
  1422.     fi
  1423.     a= z=;;
  1424. *)
  1425.     h=? a='/* ' z='*/ '
  1426. esac
  1427. echo "$a#define has__doprnt $h $z/* Does _doprnt() work?  */"
  1428.  
  1429. echo >&3 $0: configuring EXIT_FAILURE
  1430. cat >a.c <<'EOF'
  1431. #include "a.h"
  1432. int main() { exitmain(EXIT_FAILURE); }
  1433. EOF
  1434. $RM || exit
  1435. if $CL a.c $L >&2 && $aout
  1436. then a= z=
  1437. else a='/* ' z='*/ '
  1438. fi
  1439. echo "$a#undef EXIT_FAILURE $z/* Uncomment this if EXIT_FAILURE is broken.  */"
  1440.  
  1441. : configuring large_memory
  1442. echo "#define large_memory $has_mmap /* Can main memory hold entire RCS files?  */"
  1443.  
  1444. echo >&3 $0: configuring LONG_MAX
  1445. cat >a.c <<'EOF'
  1446. #include "a.h"
  1447. unsigned long ulong_max;
  1448. long long_max;
  1449. int main()
  1450. {
  1451.     ulong_max--;
  1452.     long_max = ulong_max >> 1;
  1453.     printf("#ifndef LONG_MAX\n");
  1454.     printf("#define LONG_MAX %ldL /* long maximum */\n", long_max);
  1455.     printf("#endif\n");
  1456.     exitmain(0);
  1457. }
  1458. EOF
  1459. $RM && $CL a.c $L >&2 && $aout || exit
  1460.  
  1461. : configuring same_file
  1462. echo "/* Do struct stat s and t describe the same file?  Answer d if unknown.  */"
  1463. echo "#define same_file(s,t,d) ((s).st_ino==(t).st_ino && (s).st_dev==(t).st_dev)"
  1464.  
  1465. echo >&3 $0: configuring struct utimbuf
  1466. cat >a.c <<'EOF'
  1467. #include "a.h"
  1468. struct utimbuf s;
  1469. int main() { s.actime = s.modtime = 1; exitmain(utime("a.c", &s) != 0); }
  1470. EOF
  1471. $RM || exit
  1472. if ($CL a.c $L && $aout) >&2
  1473. then h=1
  1474. else h=0
  1475. fi
  1476. echo "#define has_utimbuf $h /* Does struct utimbuf work?  */"
  1477.  
  1478. : configuring CO
  1479. echo "#define CO \"${RCSPREFIX}co\" /* name of 'co' program */"
  1480.  
  1481. : configuring COMPAT2
  1482. echo "#define COMPAT2 $COMPAT2 /* Are version 2 files supported?  */"
  1483.  
  1484. echo >&3 $0: configuring DATEFORM
  1485. cat >a.c <<'EOF'
  1486. #include "a.h"
  1487. int main() { printf("%.2d", 1); exitmain(0); }
  1488. EOF
  1489. $RM && $CL a.c $L >&2 && r=`$aout` || exit
  1490. case $r in
  1491. 01)    f=%.2d;;
  1492. *)    f=%02d
  1493. esac
  1494. echo "#define DATEFORM \"$f.$f.$f.$f.$f.${f}\" /* e.g. 01.01.01.01.01.01 */"
  1495.  
  1496. : configuring DIFF
  1497. echo "#define DIFF \"${DIFF}\" /* name of 'diff' program */"
  1498.  
  1499. : configuring DIFF3
  1500. echo "#define DIFF3 \"${DIFF3}\" /* name of 'diff3' program */"
  1501.  
  1502. : configuring DIFF3_A
  1503. echo "#define DIFF3_A $DIFF3_A /* Does diff3 have an -A option?  */"
  1504.  
  1505. : configuring DIFF3_BIN
  1506. echo "#define DIFF3_BIN $DIFF3_BIN /* Is diff3 user-visible (not the /usr/lib auxiliary)?  */"
  1507.  
  1508. : configuring DIFF_FLAGS
  1509. dfs=
  1510. for df in $DIFF_FLAGS
  1511. do dfs="$dfs, \"${df}\""
  1512. done
  1513. echo "#define DIFF_FLAGS $dfs /* Make diff output suitable for RCS.  */"
  1514.  
  1515. : configuring DIFF_L
  1516. echo "#define DIFF_L $DIFF_L /* Does diff -L work? */"
  1517.  
  1518. : configuring DIFF_SUCCESS, DIFF_FAILURE, DIFF_TROUBLE
  1519. cat <<EOF
  1520. #define DIFF_SUCCESS $DIFF_SUCCESS /* DIFF status if no differences are found */
  1521. #define DIFF_FAILURE $DIFF_FAILURE /* DIFF status if differences are found */
  1522. #define DIFF_TROUBLE $DIFF_TROUBLE /* DIFF status if trouble */
  1523. EOF
  1524.  
  1525. : configuring ED
  1526. echo "#define ED \"${ED}\" /* name of 'ed' program (used only if !DIFF3_BIN) */"
  1527.  
  1528. : configuring MERGE
  1529. echo "#define MERGE \"${RCSPREFIX}merge\" /* name of 'merge' program */"
  1530.  
  1531. : configuring '*SLASH*', ROOTPATH, TMPDIR, X_DEFAULT
  1532. case ${PWD-`pwd`} in
  1533. /*) # Posix
  1534.     SLASH=/
  1535.     qSLASH="'/'"
  1536.     SLASHes=$qSLASH
  1537.     isSLASH='#define isSLASH(c) ((c) == SLASH)'
  1538.     ROOTPATH='isSLASH((p)[0])'
  1539.     X_DEFAULT=",v$SLASH";;
  1540. ?:[/\\\\]*) # MS-DOS # \\\\ instead of \\ doesn't hurt, and avoids common bugs
  1541.     SLASH='\'
  1542.     qSLASH="'\\\\'"
  1543.     SLASHes="$qSLASH: case '/': case ':'"
  1544.     isSLASH='int isSLASH P((int));'
  1545.     ROOTPATH="(isSLASH((p)[0]) || (p)[0] && (p)[1]==':')"
  1546.     X_DEFAULT="$SLASH,v";;
  1547. *)
  1548.     echo >&2 "cannot deduce SLASH"; exit 1
  1549. esac
  1550. cat <<EOF
  1551. #define TMPDIR "${SLASH}tmp" /* default directory for temporary files */
  1552. #define SLASH $qSLASH /* principal filename separator */
  1553. #define SLASHes $SLASHes /* \`case SLASHes:' labels all filename separators */
  1554. $isSLASH /* Is arg a filename separator?  */
  1555. #define ROOTPATH(p) $ROOTPATH /* Is p an absolute pathname?  */
  1556. #define X_DEFAULT "$X_DEFAULT" /* default value for -x option */
  1557. EOF
  1558.  
  1559. echo >&3 $0: configuring ALL_ABSOLUTE, DIFF_ABSOLUTE
  1560. cat >a.c <<'EOF'
  1561. #include "a.h"
  1562. #ifndef isSLASH
  1563. int isSLASH(c) int c; { switch (c) { case SLASHes: return 1; } return 0; }
  1564. #endif
  1565. main(argc, argv) char **argv; { exitmain(1<argc && !ROOTPATH(argv[1])); }
  1566. EOF
  1567. $RM && ($CL a.c $L && $aout) >&2 || exit
  1568. a=1
  1569. for i in "$DIFF" "$DIFF3" "$ED" "$RCSPREFIX" "$SENDMAIL"
  1570. do
  1571.     case $i in
  1572.     \"*\") i=`expr "$i" : '"\(.*\)"'`
  1573.     esac
  1574.     case $i in
  1575.     ?*) $aout "$i" || { a=0; break; }
  1576.     esac
  1577. done
  1578. echo "#define ALL_ABSOLUTE $a /* Do all subprograms satisfy ROOTPATH?  */"
  1579. if $aout "$DIFF"
  1580. then a=1
  1581. else a=0
  1582. fi
  1583. echo "#define DIFF_ABSOLUTE $a /* Is ROOTPATH(DIFF) true?  */"
  1584.  
  1585. : configuring SENDMAIL
  1586. case $SENDMAIL in
  1587. '') a='/* ' z='*/ ';;
  1588. *) a= z=
  1589. esac
  1590. echo "$a#define SENDMAIL $SENDMAIL $z/* how to send mail */"
  1591.  
  1592. : configuring TZ_must_be_set
  1593. echo "#define TZ_must_be_set 0 /* Must TZ be set for gmtime() to work?  */"
  1594.  
  1595.  
  1596. echo >&3 $0: configuring standard library declarations...
  1597.  
  1598. cat <<'EOF'
  1599.  
  1600.  
  1601.  
  1602. /* Adjust the following declarations as needed.  */
  1603.  
  1604.  
  1605. #ifndef exiting
  1606. #    if __GNUC__ && !__STRICT_ANSI__
  1607. #        define exiting volatile /* GCC extension: function cannot return */
  1608. #    else
  1609. #        define exiting
  1610. #    endif
  1611. #endif
  1612. EOF
  1613.  
  1614. cat >a.ha <<EOF
  1615.  
  1616. #if has_ftruncate
  1617.     int ftruncate P((int,off_t));
  1618. #endif
  1619.  
  1620. /* <sys/mman.h> */
  1621. #if has_madvise
  1622.     int madvise P((caddr_t,size_t,int));
  1623. #endif
  1624. #if has_mmap
  1625.     caddr_t mmap P((caddr_t,size_t,int,int,int,off_t));
  1626.     int munmap P((caddr_t,size_t));
  1627. #endif
  1628.  
  1629.  
  1630. /* Posix (ISO/IEC 9945-1: 1990 / IEEE Std 1003.1-1990) */
  1631. /* These definitions are for the benefit of non-Posix hosts, and */
  1632. /* Posix hosts that have Standard C compilers but traditional include files.  */
  1633. /* Unfortunately, mixed-up hosts are all too common.  */
  1634.  
  1635. /* <fcntl.h> */
  1636. #ifdef F_DUPFD
  1637.     int fcntl P((int,int,...));
  1638. #else
  1639.     int dup2 P((int,int));
  1640. #endif
  1641. #ifdef O_CREAT
  1642. #    define open_can_creat 1
  1643. #else
  1644. #    define open_can_creat 0
  1645. #    define O_RDONLY 0
  1646. #    define O_WRONLY 1
  1647. #    define O_RDWR 2
  1648. #    define O_CREAT 01000
  1649. #    define O_TRUNC 02000
  1650.     int creat P((char const*,mode_t));
  1651. #endif
  1652. #ifndef O_EXCL
  1653. #define O_EXCL 0
  1654. #endif
  1655.  
  1656. /* <pwd.h> */
  1657. #if has_getpwuid
  1658.     struct passwd *getpwuid P((uid_t));
  1659. #endif
  1660.  
  1661. /* <signal.h> */
  1662. #if has_sigaction
  1663.     int sigaction P((int,struct sigaction const*,struct sigaction*));
  1664.     int sigaddset P((sigset_t*,int));
  1665.     int sigemptyset P((sigset_t*));
  1666. #else
  1667. #if has_sigblock
  1668.     /* BSD */
  1669.     int sigblock P((int));
  1670.     int sigmask P((int));
  1671.     int sigsetmask P((int));
  1672. #endif
  1673. #endif
  1674.  
  1675. /* <stdio.h> */
  1676. FILE *fdopen P((int,char const*));
  1677. int fileno P((FILE*));
  1678.  
  1679. /* <sys/stat.h> */
  1680. int chmod P((char const*,mode_t));
  1681. int fstat P((int,struct stat*));
  1682. int stat P((char const*,struct stat*));
  1683. #if has_fchmod
  1684.     int fchmod P((int,mode_t));
  1685. #endif
  1686. #ifndef S_IRUSR
  1687. #    ifdef S_IREAD
  1688. #        define S_IRUSR S_IREAD
  1689. #    else
  1690. #        define S_IRUSR 0400
  1691. #    endif
  1692. #    ifdef S_IWRITE
  1693. #        define S_IWUSR S_IWRITE
  1694. #    else
  1695. #        define S_IWUSR (S_IRUSR/2)
  1696. #    endif
  1697. #endif
  1698. #ifndef S_IRGRP
  1699. #    if has_getuid
  1700. #        define S_IRGRP (S_IRUSR / 0010)
  1701. #        define S_IWGRP (S_IWUSR / 0010)
  1702. #        define S_IROTH (S_IRUSR / 0100)
  1703. #        define S_IWOTH (S_IWUSR / 0100)
  1704. #    else
  1705.         /* single user OS -- not Posix or Unix */
  1706. #        define S_IRGRP 0
  1707. #        define S_IWGRP 0
  1708. #        define S_IROTH 0
  1709. #        define S_IWOTH 0
  1710. #    endif
  1711. #endif
  1712. #ifndef S_ISREG
  1713. #define S_ISREG(n) (((n) & S_IFMT) == S_IFREG)
  1714. #endif
  1715.  
  1716. /* <sys/wait.h> */
  1717. #if has_wait
  1718.     pid_t wait P((int*));
  1719. #endif
  1720. #ifndef WEXITSTATUS
  1721. #define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
  1722. #undef WIFEXITED /* Avoid 4.3BSD incompatibility with Posix.  */
  1723. #endif
  1724. #ifndef WIFEXITED
  1725. #define WIFEXITED(stat_val) (!((stat_val) & 255))
  1726. #endif
  1727.  
  1728. /* <unistd.h> */
  1729. char *getlogin P((void));
  1730. int close P((int));
  1731. int isatty P((int));
  1732. int link P((char const*,char const*));
  1733. int open P((char const*,int,...));
  1734. int unlink P((char const*));
  1735. int _filbuf P((FILE*)); /* keeps lint quiet in traditional C */
  1736. int _flsbuf P((int,FILE*)); /* keeps lint quiet in traditional C */
  1737. long pathconf P((char const*,int));
  1738. ssize_t write P((int,void const*,size_t));
  1739. #ifndef STDIN_FILENO
  1740. #    define STDIN_FILENO 0
  1741. #    define STDOUT_FILENO 1
  1742. #    define STDERR_FILENO 2
  1743. #endif
  1744. #if has_fork
  1745. #    if !has_vfork
  1746. #        undef vfork
  1747. #        define vfork fork
  1748. #    endif
  1749.     pid_t vfork P((void)); /* vfork is nonstandard but faster */
  1750. #endif
  1751. #if has_getcwd || !has_getwd
  1752.     char *getcwd P((char*,size_t));
  1753. #else
  1754.     char *getwd P((char*));
  1755. #endif
  1756. #if has_getuid
  1757.     uid_t getuid P((void));
  1758. #endif
  1759. #if has_readlink
  1760.     ssize_t readlink P((char const*,char*,size_t)); /* BSD; not standard yet */
  1761. #endif
  1762. #if has_setuid
  1763. #    if !has_seteuid
  1764. #        undef seteuid
  1765. #        define seteuid setuid
  1766. #    endif
  1767.     int seteuid P((uid_t));
  1768.     uid_t geteuid P((void));
  1769. #endif
  1770. #if has_spawn
  1771.     int spawnv P((int,char const*,char*const*));
  1772. #    if ALL_ABSOLUTE
  1773. #        define spawn_RCS spawnv
  1774. #    else
  1775. #        define spawn_RCS spawnvp
  1776.         int spawnvp P((int,char const*,char*const*));
  1777. #    endif
  1778. #else
  1779.     int execv P((char const*,char*const*));
  1780. #    if ALL_ABSOLUTE
  1781. #        define exec_RCS execv
  1782. #    else
  1783. #        define exec_RCS execvp
  1784.         int execvp P((char const*,char*const*));
  1785. #    endif
  1786. #endif
  1787.  
  1788. /* utime.h */
  1789. #if !has_utimbuf
  1790.     struct utimbuf { time_t actime, modtime; };
  1791. #endif
  1792. int utime P((char const*,struct utimbuf const*));
  1793.  
  1794.  
  1795. /* Standard C library */
  1796. /* These definitions are for the benefit of hosts that have */
  1797. /* traditional C include files, possibly with Standard C compilers.  */
  1798. /* Unfortunately, mixed-up hosts are all too common.  */
  1799.  
  1800. /* <errno.h> */
  1801. extern int errno;
  1802.  
  1803. /* <signal.h> */
  1804. #if has_signal
  1805.     signal_type (*signal P((int,signal_type(*)signal_args)))signal_args;
  1806. #endif
  1807.  
  1808. /* <stdio.h> */
  1809. FILE *fopen P((char const*,char const*));
  1810. fread_type fread P((void*,freadarg_type,freadarg_type,FILE*));
  1811. fread_type fwrite P((void const*,freadarg_type,freadarg_type,FILE*));
  1812. int fclose P((FILE*));
  1813. int feof P((FILE*));
  1814. int ferror P((FILE*));
  1815. int fflush P((FILE*));
  1816. int fprintf P((FILE*,char const*,...));
  1817. int fputs P((char const*,FILE*));
  1818. int fseek P((FILE*,long,int));
  1819. int printf P((char const*,...));
  1820. int rename P((char const*,char const*));
  1821. int sprintf P((char*,char const*,...));
  1822. long ftell P((FILE*));
  1823. void clearerr P((FILE*));
  1824. void perror P((char const*));
  1825. #ifndef L_tmpnam
  1826. #define L_tmpnam 32 /* power of 2 > sizeof("/usr/tmp/xxxxxxxxxxxxxxx") */
  1827. #endif
  1828. #ifndef SEEK_SET
  1829. #define SEEK_SET 0
  1830. #endif
  1831. #if has_mktemp
  1832.     char *mktemp P((char*)); /* traditional */
  1833. #else
  1834.     char *tmpnam P((char*));
  1835. #endif
  1836. #if has_vfprintf
  1837.     int vfprintf P((FILE*,char const*,va_list));
  1838. #else
  1839. #if has__doprintf
  1840.     void _doprintf P((FILE*,char const*,va_list)); /* Minix */
  1841. #else
  1842.     void _doprnt P((char const*,va_list,FILE*)); /* BSD */
  1843. #endif
  1844. #endif
  1845.  
  1846. /* <stdlib.h> */
  1847. char *getenv P((char const*));
  1848. exiting void _exit P((int));
  1849. exiting void exit P((int));
  1850. malloc_type malloc P((size_t));
  1851. malloc_type realloc P((malloc_type,size_t));
  1852. void free P((malloc_type));
  1853. #ifndef EXIT_FAILURE
  1854. #define EXIT_FAILURE 1
  1855. #endif
  1856. #ifndef EXIT_SUCCESS
  1857. #define EXIT_SUCCESS 0
  1858. #endif
  1859. #if !has_fork && !has_spawn
  1860.     int system P((char const*));
  1861. #endif
  1862.  
  1863. /* <string.h> */
  1864. char *strcpy P((char*,char const*));
  1865. char *strchr P((char const*,int));
  1866. char *strrchr P((char const*,int));
  1867. int memcmp P((void const*,void const*,size_t));
  1868. int strcmp P((char const*,char const*));
  1869. size_t strlen P((char const*));
  1870. void *memcpy P((void*,void const*,size_t));
  1871. #if has_memmove
  1872.     void *memmove P((void*,void const*,size_t));
  1873. #endif
  1874.  
  1875. /* <time.h> */
  1876. time_t time P((time_t*));
  1877. EOF
  1878.  
  1879. cat >a.c <<'EOF'
  1880. #include "a.h"
  1881. #define a 0
  1882. #define b 1
  1883. #if H==a
  1884. #    include "a.ha"
  1885. #else
  1886. #    include "a.hb"
  1887. #endif
  1888. int main() { exitmain(0); }
  1889. EOF
  1890.  
  1891. # Comment out lines in a.ha that the compiler rejects.
  1892. # a.ha may not contain comments that cross line boundaries.
  1893. # Leave the result in a.h$H.
  1894. H=a L=1
  1895. U=`wc -l <a.ha | sed 's| ||g'`
  1896. commentOut='s|^[^#/][^/]*|/* & */|'
  1897.  
  1898. until  test $U -lt $L  ||  $CS -DH=$H a.c $LS >&2
  1899. do
  1900.     case $H in
  1901.     a) I=b;;
  1902.     *) I=a
  1903.     esac
  1904.  
  1905.     # The compiler rejects some line in L..U.
  1906.     # Use binary search to set L to be the index of the first bad line in L..U.
  1907.     u=$U
  1908.     while test $L -lt $u
  1909.     do
  1910.         M=`expr '(' $L + $u ')' / 2`
  1911.         M1=`expr $M + 1`
  1912.         sed "$M1,\$$commentOut" a.h$H >a.h$I || exit
  1913.         if $CS -DH=$I a.c $LS >&2
  1914.         then L=$M1
  1915.         else u=$M
  1916.         fi
  1917.     done
  1918.  
  1919.     # Comment out the bad line.
  1920.     badline=`sed -n "$L{p;q;}" a.h$H`
  1921.     echo >&3 $0: commenting out "\`$badline'"
  1922.     sed "$L$commentOut" a.h$H >a.h$I || exit
  1923.  
  1924.     H=$I
  1925.     L=`expr $L + 1`
  1926. done
  1927.  
  1928. cat a.h$H
  1929.